#include "menues.h"

void Menues::op_modif_emails(Sistema& sistema, Usuario& aModificar) {
	Menu menu_modif_emails;
	menu_modif_emails.setTitulo("Seleccione el email que desea modificar:");
	menu_modif_emails.setOpcionDeSalida("Volver");

	menu_modif_emails.addOpcion(aModificar.getEmail());
	for(int i=1; i<3; i++)
		if(!aModificar.getEmail(i).empty())
			menu_modif_emails.addOpcion(aModificar.getEmail(i));
		else {
			menu_modif_emails.addOpcion("Agregar Email");
			break;
		}

	Formulario cambiarEmail("Ingrese nuevo email");
	cambiarEmail.setAtributos(0,3,100);

	int op_elegida = menu_modif_emails.mostrarOpciones();

	if(!menu_modif_emails.salir()) {
		cambiarEmail.pedirDatos();
		aModificar.setEmail(op_elegida-1,cambiarEmail.getDatoAsStr(0));
	}
}

void Menues::menu_modif_usuarios(Sistema& sistema, int dni) {
	Usuario aModificar;
	sistema.recuperarUsuario(dni, aModificar);

	Menu menu_modif("Nombre,Apellido,Emails,Password,Provincia,Volver");
	menu_modif.setTitulo("Seleccione el campo que desea cambiar:");
	menu_modif.setMensajeDeExito(4,"Password cambiada con exito");
	menu_modif.setMensajeDeFracaso(4,"Las passwords no coinciden: no se realizó el cambio");

	Formulario cambiarNombre("Ingrese nuevo nombre");
	cambiarNombre.setAtributos(0,2,100);
	Formulario cambiarApellido("Ingrese nuevo apellido");
	cambiarApellido.setAtributos(0,2,100);
	Formulario cambiarPassword("Ingrese nueva password,Repitala para verificarla");
	cambiarPassword.setAtributos(0,9,9);
	Formulario cambiarProvincia("Ingrese nueva provincia");
	cambiarProvincia.setAtributos(0,2,100);

	int op_elegida = 0;
	while(op_elegida != 6) {
		op_elegida = menu_modif.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			cambiarNombre.pedirDatos();
			aModificar.setNombre(cambiarNombre.getDatoAsStr(0));
			break;
		}
		case 2: {
			cambiarApellido.pedirDatos();
			aModificar.setApellido(cambiarApellido.getDatoAsStr(0));
			break;
		}
		case 3: {
			op_modif_emails(sistema, aModificar);
			break;
		}
		case 4: {
			cambiarPassword.pedirDatos();
			while(!sistema.passwordValida(cambiarPassword.getDatoAsStr(0))) {
				cout << "La contraseña tiene caracteres inválidos, intente nuevamente" << endl;
				cambiarPassword.pedirDatos(0);
			}
			bool coinciden = cambiarPassword.getDatoAsStr(0) == cambiarPassword.getDatoAsStr(1);
			if(coinciden)
				aModificar.setPassword(cambiarPassword.getDatoAsStr(0));
			menu_modif.mostrarMensaje(coinciden);
			break;
		}
		case 5: {
			cambiarProvincia.pedirDatos();
			aModificar.setProvincia(cambiarProvincia.getDatoAsStr(0));
			break;
		}
		};
	}
	sistema.modificarUsuario(aModificar);
}

bool Menues::menu_servicio(Sistema& sistema, int idServicio, int dni) {
	Servicio servicio;
	if(sistema.consultarServicioPorId(idServicio, servicio)) {
		Menu menu_servicio("Realizar consulta,Pedir cotización,Volver");
		menu_servicio.setTitulo("Acciones");
		menu_servicio.setMensajeDeExito(1,"Su consulta se generó con exito");
		menu_servicio.setMensajeDeFracaso(1,"Error del sistema: no se pudo generar la consulta");
		menu_servicio.setMensajeDeExito(2,"Su pedido de cotización se generó con exito");
		menu_servicio.setMensajeDeFracaso(2,"Error del sistema: no se pudo generar el pedido");

		Formulario consulta("Escriba su consulta al proveedor");
		consulta.setAtributos(0,1,140);
		Formulario cotizacion("Escriba su pedido de cotización al proveedor");
		cotizacion.setAtributos(0,1,1000);

		Usuario proveedor;
		sistema.recuperarUsuario(servicio.getIdProveedor(), proveedor);

		int op_elegida = 0;
		while(op_elegida != 3) {
			/*******/
			cout << ">> "+servicio.getNombre()+" <<" << endl;
			cout << "Proveedor: " << proveedor.getId();
			cout << ", "+proveedor.getNombre()+" "+proveedor.getApellido() << endl;
			cout << "Descripcion:" << endl << servicio.getDescripcion() << endl;
			cout << "Consultas realizadas:" << endl;
			std::vector<Consulta> consultas;
			sistema.listarConsultasPorServicio(idServicio, &consultas);
			for(unsigned int i=0; i<consultas.size(); i++) {
				if(!consultas[i].estaOculta()) {
					cout << "_Q: "+consultas[i].getConstulta().texto << endl;
					cout << "__A: "+consultas[i].getRespuesta().texto << endl;
				}
			}
			/*******/
			op_elegida = menu_servicio.mostrarOpciones();

			switch(op_elegida) {
			case 1: {
				consulta.pedirDatos();
				menu_servicio.mostrarMensaje(sistema.realizarConsulta(
						idServicio, dni, consulta.getDatoAsStr(0)));
				break;
			}
			case 2: {
				cotizacion.pedirDatos();
				menu_servicio.mostrarMensaje(sistema.realizarPedidoDeCotizacion(
						idServicio, dni, cotizacion.getDatoAsStr(0)));
				break;
			}
			};
		}
		return true;
	}
	return false;
}

bool Menues::menu_lista_de_servicios(Sistema& sistema, int dni, std::vector<Servicio>* servicios) {
	if(!servicios->empty()) {
		Menu lista_servicios;
		lista_servicios.setTitulo("Servicios encontrados, seleccione uno para ver detalles");
		lista_servicios.setOpcionDeSalida("Volver");

		for(unsigned int i=0; i<servicios->size(); i++)
			lista_servicios.addOpcion((*servicios)[i].getNombre());

		while(!lista_servicios.salir()) {
			int op_elegida = lista_servicios.mostrarOpciones();

			if(!lista_servicios.salir()) {
				menu_servicio(sistema, (*servicios)[op_elegida-1].getId(), dni);
			}
		}
		return true;
	}
	return false;
}

void Menues::menu_consultar_servicios(Sistema& sistema, int dni) {
	Menu menu_consul_serv("Por proveedor,Por servicio,Por categorias,Por palabra clave,Volver");
	menu_consul_serv.setTitulo("Consultar Servicios");
	menu_consul_serv.setMensajeDeFracaso(1,"El proveedor especificado no tiene servicios");
	menu_consul_serv.setMensajeDeFracaso(2,"El servicio especificado no existe");
	menu_consul_serv.setMensajeDeFracaso(3,"No hay servicios bajo esa categoría");
	menu_consul_serv.setMensajeDeFracaso(4,"No hubo resultados de servicios");

	Formulario porProveedor("Ingrese el DNI del proveedor");
	porProveedor.setAtributos(0,7,8,true);
	Formulario porServicio("Ingrese el ID del servicio");
	porServicio.setAtributos(0,1,8,true);
	Formulario porCategoria("Ingrese el nombre de la categoria");
	porCategoria.setAtributos(0,1,100);
	Formulario porPalabra("Ingrese la palabra clave");
	porPalabra.setAtributos(0,1,100);

	int op_elegida = 0;
	while(op_elegida != 5) {
		op_elegida = menu_consul_serv.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			porProveedor.pedirDatos();
			std::vector<Servicio> servicios;
			sistema.consultarServiciosPorProveedor(
					porProveedor.getDatoAsInt(0), &servicios);
			menu_consul_serv.mostrarMensaje(
					menu_lista_de_servicios(sistema, dni, &servicios));
			break;
		}
		case 2: {
			porServicio.pedirDatos();
			menu_consul_serv.mostrarMensaje(
					menu_servicio(sistema, porServicio.getDatoAsInt(0), dni));
			break;
		}
		case 3: {
			porCategoria.pedirDatos();
			std::vector<Servicio> servicios;
			sistema.consultarServiciosPorCategoria(
					porCategoria.getDatoAsStr(0), &servicios);
			menu_consul_serv.mostrarMensaje(
					menu_lista_de_servicios(sistema, dni, &servicios));
			break;
		}
		case 4: {
			porPalabra.pedirDatos();
			std::vector<Servicio> servicios;
			sistema.consultarServicioPorPalabraClave(
					porPalabra.getDatoAsStr(0), &servicios);
			menu_consul_serv.mostrarMensaje(
					menu_lista_de_servicios(sistema, dni, &servicios));
			break;
		}
		};
	}
}

bool Menues::modo_listar_categorias(Sistema& sistema, std::vector<Categoria>* lista) {
	Menu modo_de_listar("Listar todas las categorias existentes,Listar categorias por palabra clave");
	modo_de_listar.setTitulo("Listar Categorias");
	modo_de_listar.setOpcionDeSalida("Cancelar");

	Formulario porPalabra("Ingrese la palabra clave");
	porPalabra.setAtributos(0,1,100);

	int modo = modo_de_listar.mostrarOpciones();
	switch(modo) {
	case 1: {
		sistema.listarCategorias(lista);
		break;
	}
	case 2: {
		porPalabra.pedirDatos();
		sistema.listarCategoriasPorPalabraClave(porPalabra.getDatoAsStr(0), lista);
		break;
	}
	};

	return !modo_de_listar.salir();
}

bool Menues::op_asoc_serv_categ(Sistema& sistema, int dni) {
	std::vector<Servicio> servicios;
	sistema.consultarServiciosPorProveedor(dni, &servicios);

	if(servicios.empty()) {
		cout << "Usted no dispone de servicios" << endl;
		return false;
	}
	Menu lista_servicios;
	lista_servicios.setTitulo("Seleccione el servicio que quiere agregar a una categoria");
	for(unsigned int i=0; i<servicios.size(); i++)
		lista_servicios.addOpcion(servicios[i].getNombre());

	int serv = lista_servicios.mostrarOpciones();

	std::vector<Categoria> categorias;
	if(!modo_listar_categorias(sistema, &categorias))
		return false;

	if(categorias.empty()) {
		cout << "No hay categorías existentes" << endl;
		return false;
	}
	Menu lista_categorias;
	lista_categorias.setTitulo("Seleccione la categoria donde agregar el servicio");
	for(unsigned int i=0; i<categorias.size(); i++)
		lista_categorias.addOpcion(categorias[i].getNombre());

	int categ = lista_categorias.mostrarOpciones();

	string msj = "Confirma la categorizacion de "+servicios[serv-1].getNombre();
	msj += " en "+categorias[categ-1].getNombre()+"?";
	if(Menu::pedirConfirmacion(msj)) {
		bool result = sistema.asociarServicioACategoria(servicios[serv-1].getId(), categorias[categ-1].getId());
		if(!result)
			cout << "Error del sistema: ";
		return result;
	}

	return false;
}

int Menues::op_responder_preguntas(Sistema& sistema, int dni) {
	Menu lista_preguntas;
	lista_preguntas.setTitulo("Seleccione la pregunta que quiere responder");
	lista_preguntas.setOpcionDeSalida("Volver");

	std::vector<Servicio> servicios;
	sistema.consultarServiciosPorProveedor(dni, &servicios);

	std::vector<int> idConsultas;
	for(unsigned int i=0; i<servicios.size(); i++) {
		std::vector<Consulta> consultas;
		sistema.listarConsultasPorServicio(servicios[i].getId(), &consultas);
		if(!consultas.empty()) {
			int posSubTitulo = 0;
			for(unsigned int j=0; j<consultas.size(); j++)
				if(!consultas[j].estaOculta() && consultas[j].getRespuesta().texto.empty()) {
					lista_preguntas.addOpcion("_Q: "+consultas[j].getConstulta().texto);
					idConsultas.push_back(consultas[j].getId());
					posSubTitulo++;
				}
			if(posSubTitulo)
				lista_preguntas.addSubTituloIntercalado(
						servicios[i].getNombre()+":", idConsultas.size()-posSubTitulo+1);
		}
	}

	if(!idConsultas.empty()) {
		cout << "!> Se listan solo las consultas que no tienen respuesta" << endl;
		int consul = lista_preguntas.mostrarOpciones();

		if(!lista_preguntas.salir())
			return idConsultas[consul-1];
	}
	else
		cout << "No hay preguntas sin responder en ningún servicio" << endl;

	return -1;
}

void Menues::op_ver_cotizaciones(Sistema& sistema, int dni) {
	cout << "- Estos son los pedidos de cotización que recibió cada servicio -" << endl;

	std::vector<Servicio> servicios;
	sistema.consultarServiciosPorProveedor(dni, &servicios);

	for(unsigned int i=0; i<servicios.size(); i++) {
		std::vector<Cotizacion> cotizaciones;
		sistema.listarCotizacionesPorServicio(servicios[i].getId(), &cotizaciones);
		if(!cotizaciones.empty()) {
			cout << "- - - - - - - - - - - - - - -" << endl;
			cout << servicios[i].getNombre()+":" << endl;
			cout << "- - - - - - - - - - - - - - -" << endl;
			for(unsigned int j=0; j<cotizaciones.size(); j++) {
				cout << "*****************************" << endl;
				cout << "Usuario interesado: " << cotizaciones[j].getIdUsuario() << endl;
				cout << "Pedido: " << endl << "	"+cotizaciones[j].getPedido().texto << endl;
			}
		}
	}

	Menu::pressEnterToContinue("\n!> Presione -ENTER- para volver");
}

void Menues::menu_admin_servicios(Sistema& sistema, int dni) {
	Menu menu_admin_serv("Crear servicio,Eliminar servicio,Asociar servicio a categoria,Responder preguntas,Ver pedidos de cotización,Volver");
	menu_admin_serv.setTitulo("Administrar Servicios");
	menu_admin_serv.setMensajeDeExito(1,"El servicio se creó exitosamente");
	menu_admin_serv.setMensajeDeFracaso(1,"Error del sistema: no se pudo crear el servicio");
	menu_admin_serv.setMensajeDeExito(2,"El servicio se dio de baja");
	menu_admin_serv.setMensajeDeFracaso(2,"Error del sistema: no se pudo eliminar el servicio");
	menu_admin_serv.setMensajeDeExito(3,"La asociacion se realizó con exito");
	menu_admin_serv.setMensajeDeFracaso(3,"No se realizó la asociacion");
	menu_admin_serv.setMensajeDeExito(4,"La consulta fue respondida");
	menu_admin_serv.setMensajeDeFracaso(4,"Error del sistema: no se pudo responder la consulta");

	Formulario registro("Nombre,Descripcion");
	registro.setAtributos(0,1,100);
	registro.setAtributos(1,1,300);
	Menu lista_de_tipos("Gratuito,Precio Fijo,Subasta");
	Formulario eliminarServ("Ingrese el Id del servicio a dar de baja");
	eliminarServ.setAtributos(0,1,8,true);
	Formulario respuesta("Ingrese el texto de la respuesta");
	respuesta.setAtributos(0,1,140);

	int op_elegida = 0;
	while(op_elegida != 6) {
		op_elegida = menu_admin_serv.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			registro.pedirDatos();
			cout << "Seleccione el tipo de servicio:" << endl;
			int op = lista_de_tipos.mostrarOpciones();
			string tipo = "GR";
			if(op==2)
				tipo = "PF";
			else if(op==3)
				tipo = "SU";

			Servicio nuevo(sistema.getIdIncrementalDeServicios());
			nuevo.setIdProveedor(dni);
			nuevo.setNombre(registro.getDatoAsStr(0));
			nuevo.setDescripcion(registro.getDatoAsStr(1));
			nuevo.setTipo(tipo);

			menu_admin_serv.mostrarMensaje(sistema.crearServicio(nuevo));
			break;
		}
		case 2: {
			eliminarServ.pedirDatos();
			menu_admin_serv.mostrarMensaje(sistema.eliminarServicio(
					eliminarServ.getDatoAsInt(0)));
			break;
		}
		case 3: {
			menu_admin_serv.mostrarMensaje(op_asoc_serv_categ(sistema, dni));
			break;
		}
		case 4: {
			int idConsulta = op_responder_preguntas(sistema, dni);
			if(idConsulta > -1) {
				respuesta.pedirDatos();
				menu_admin_serv.mostrarMensaje(sistema.responderConsulta(
						idConsulta, respuesta.getDatoAsStr(0)));
			}
			break;
		}
		case 5: {
			op_ver_cotizaciones(sistema, dni);
			break;
		}
		};
	}
}

int Menues::menu_lista_de_categorias(Sistema& sistema, string titulo) {
	std::vector<Categoria> categorias;
	if(!modo_listar_categorias(sistema, &categorias))
		return 0;

	if(categorias.empty()) {
		cout << "No se encontraron categorias" << endl;
		return 0;
	}
	Menu lista_categorias;
	lista_categorias.setTitulo(titulo);
	lista_categorias.setOpcionDeSalida("Volver");

	for(unsigned int i=0; i<categorias.size(); i++)
		lista_categorias.addOpcion(categorias[i].getNombre());

	int op_elegida = lista_categorias.mostrarOpciones();

	if(!lista_categorias.salir())
		return categorias[op_elegida-1].getId();

	return 0;
}

void Menues::op_modif_categoria(Sistema& sistema, int idCategoria) {
	Categoria aModificar;
	sistema.recuperarCategoria(idCategoria, aModificar);

	Menu menu_modif("Nombre,Descripcion,Volver");
	menu_modif.setTitulo("Seleccione el campo que desea cambiar:");

	Formulario cambiarNombre("Ingrese nuevo nombre");
	cambiarNombre.setAtributos(0,2,100);
	Formulario cambiarDescripcion("Ingrese nueva descripcion");
	cambiarDescripcion.setAtributos(0,2,300);

	int op_elegida = 0;
	while(op_elegida != 3) {
		op_elegida = menu_modif.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			cambiarNombre.pedirDatos();
			aModificar.setNombre(cambiarNombre.getDatoAsStr(0));
			break;
		}
		case 2: {
			cambiarDescripcion.pedirDatos();
			aModificar.setDescripcion(cambiarDescripcion.getDatoAsStr(0));
			break;
		}
		};
	}
	sistema.modificarCategoria(aModificar);
}

void Menues::menu_admin_categorias(Sistema& sistema) {
	Menu menu_admin_categ("Generar nueva categoría,Generar categorias desde archivo,Modificar categoría,Eliminar categoría,Volver");
	menu_admin_categ.setTitulo("Administrar Categorias");
	menu_admin_categ.setMensajeDeExito(1,"La categoría se creó exitosamente");
	menu_admin_categ.setMensajeDeFracaso(1,"Error del sistema: no se pudo crear la categoría");
	menu_admin_categ.setMensajeDeExito(2,"Se cargaron las categorías del archivo con exito");
	menu_admin_categ.setMensajeDeFracaso(2,"Error: el archivo especificado no existe");
	menu_admin_categ.setMensajeDeExito(4,"La categoría se dio de baja");
	menu_admin_categ.setMensajeDeFracaso(4,"Error del sistema: no se pudo eliminar la categoría");

	Formulario creacion("Nombre,Descripcion");
	creacion.setAtributos(0,1,100);
	creacion.setAtributos(1,1,300,false,true);
	Formulario cargaMasiva("Ingrese la ruta al archivo de categorias");
	creacion.setAtributos(0,1,200);

	int op_elegida = 0;
	while(op_elegida != 5) {
		op_elegida = menu_admin_categ.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			creacion.pedirDatos();

			Categoria nueva(sistema.getIdIncrementalDeCategorias(),
					creacion.getDatoAsStr(0));
			nueva.setDescripcion(creacion.getDatoAsStr(1));

			menu_admin_categ.mostrarMensaje(sistema.crearCategoria(nueva));
			break;
		}
		case 2: {
			cargaMasiva.pedirDatos();
			menu_admin_categ.mostrarMensaje(sistema.crearCategorias(
					cargaMasiva.getDatoAsStr(0)));
			break;
		}
		case 3: {
			string titulo = "Seleccione la categoria que quiere modificar";
			int idCategoria = menu_lista_de_categorias(sistema, titulo);
			if(idCategoria > 0)
				op_modif_categoria(sistema, idCategoria);
			break;
		}
		case 4: {
			string titulo = "Seleccione la categoria que quiere eliminar";
			int idCategoria = menu_lista_de_categorias(sistema, titulo);
			if(idCategoria > 0)
				menu_admin_categ.mostrarMensaje(sistema.eliminarCategoria(idCategoria));
			break;
		}
		};
	}
}

bool Menues::modo_listar_consultas(Sistema& sistema, std::vector<Consulta>* lista) {
	Menu modo_de_listar("Listar todas las consultas existentes,Listar consultas por palabra clave");
	modo_de_listar.setTitulo("Listar Consultas");
	modo_de_listar.setOpcionDeSalida("Cancelar");

	Formulario porPalabra("Ingrese la palabra clave");
	porPalabra.setAtributos(0,1,100);

	int modo = modo_de_listar.mostrarOpciones();
	switch(modo) {
	case 1: {
		sistema.listarConsultas(lista);
		break;
	}
	case 2: {
		porPalabra.pedirDatos();
		sistema.listarConsultasPorPalabraClave(porPalabra.getDatoAsStr(0), lista);
		break;
	}
	};

	return !modo_de_listar.salir();
}

void Menues::op_mod_consultas(Sistema& sistema) {
	struct {  // esto se ve feo pero está prolijo
		string operator() (bool visible) const {
			return string("Visibilidad: ")+(visible?"OCULTAR":"MOSTRAR");
		}
	} visibilidad;

	Menu menu_mod_consultas;
	menu_mod_consultas.setTitulo("Seleccione la consulta para cambiar su visibilidad");
	menu_mod_consultas.setOpcionDeSalida("Volver");

	std::vector<Consulta> consultas;
	if(!modo_listar_consultas(sistema, &consultas))
		return;

	if(consultas.empty()) {
		cout << "No se encontraron consultas" << endl;
		return;
	}
	for(unsigned int j=0; j<consultas.size(); j++) {
		string consulta = "************************\n";
		consulta += "_Q: "+consultas[j].getConstulta().texto+"\n";
		consulta += "__A: "+consultas[j].getRespuesta().texto;
		menu_mod_consultas.addSubTituloIntercalado(consulta);
		menu_mod_consultas.addOpcion(visibilidad(consultas[j].estaOculta()));
	}

	while(!menu_mod_consultas.salir()) {
		int op_elegida = menu_mod_consultas.mostrarOpciones();

		if(!menu_mod_consultas.salir()) {
			bool mostrar = !consultas[op_elegida-1].estaOculta();
			sistema.moderarConsultas(consultas[op_elegida-1].getId(), mostrar);
			consultas[op_elegida-1].ocultar(mostrar);
			menu_mod_consultas.modifOpcion(op_elegida, visibilidad(mostrar));
			cout << "Se cambió la visibilidad de la consulta " << op_elegida;
			cout << " a " << (mostrar?"OCULTAR":"MOSTRAR") << endl;
			if(!Menu::pedirConfirmacion("Desea moderar otras consultas?"))
				break;
		}
	}
}

void Menues::op_modif_passwords(Sistema& sistema) {
	Formulario verPassword("Ingrese el DNI del usuario para ver su contraseña");
	verPassword.setAtributos(0,7,8,true);
	Formulario modifPassword("Ingrese la nueva contraseña para el usuario");
	modifPassword.setAtributos(0,9,9);

	verPassword.pedirDatos();
	int dni = verPassword.getDatoAsInt(0);
	string pass = sistema.recuperarPassword(dni);
	if(pass.empty()) {
		cout << "El usuario especificado no existe en el sistema" << endl;
		return;
	}
	cout << "> Contraseña actual: " << pass << endl;
	if(Menu::pedirConfirmacion("Desea modificar la contraseña?")) {
		modifPassword.pedirDatos();
		while(!sistema.passwordValida(modifPassword.getDatoAsStr(0))) {
			cout << "La contraseña tiene caracteres inválidos, intente nuevamente" << endl;
			modifPassword.pedirDatos();
		}
		if(sistema.modificarPassword(dni, modifPassword.getDatoAsStr(0)))
			cout << "Se cambió la contraseña del usuario" << endl;
		else
			cout << "Error del sistema: no se pudo cambiar la contraseña" << endl;
	}
}

void Menues::menu_administrador(Sistema& sistema) {
	Menu menu_administrador("Registrar un administrador,Dar de baja un administrador,Administrar categorias,Moderar consultas,Recuperar contraseña,Desloguearse");
	menu_administrador.setTitulo("Menu de Administradores");
	menu_administrador.setMensajeDeExito(1,"Se registro al usuario como administrador");
	menu_administrador.setMensajeDeFracaso(1,"Error: el usuario especificado no existe en el sistema");
	menu_administrador.setMensajeDeExito(2,"Se eliminó al usuario del sistema");
	menu_administrador.setMensajeDeFracaso(2,"Error: el usuario especificado no existe en el sistema");

	Formulario registrarAdmin("Ingrese el DNI del administrador a registrar");
	registrarAdmin.setAtributos(0,7,8,true);
	Formulario eliminarAdmin("Ingrese el DNI del administrador a dar de baja");
	eliminarAdmin.setAtributos(0,7,8,true);

	int op_elegida = 0;
	while(op_elegida != 6) {
		op_elegida = menu_administrador.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			registrarAdmin.pedirDatos();
			int dni = registrarAdmin.getDatoAsInt(0);
			menu_administrador.mostrarMensaje(sistema.registrarAdministrador(dni));
			break;
		}
		case 2: {
			eliminarAdmin.pedirDatos();
			int dni = eliminarAdmin.getDatoAsInt(0);
			menu_administrador.mostrarMensaje(sistema.eliminarUsuario(dni));
			break;
		}
		case 3: {
			menu_admin_categorias(sistema);
			break;
		}
		case 4: {
			op_mod_consultas(sistema);
			break;
		}
		case 5: {
			op_modif_passwords(sistema);
			break;
		}
		};
	}
}

void Menues::menu_proveedor(Sistema& sistema, int dni) {
	Menu menu_proveedor("Modificar datos personales,Darse de baja,Consultar servicios,Administrar servicios,Desloguearse");
	menu_proveedor.setTitulo("Menu de Proveedores");
	menu_proveedor.setMensajeDeExito(2,"Se ha dado de baja en el sistema");
	menu_proveedor.setMensajeDeFracaso(2,"Error del sistema: no se pudo dar de baja");

	int op_elegida = 0;
	while(op_elegida != 5) {
		op_elegida = menu_proveedor.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			menu_modif_usuarios(sistema, dni);
			break;
		}
		case 2: {
			string msj = "Esta seguro que desea darse de baja en el sistema?";
			if(Menu::pedirConfirmacion(msj)) {
				if(menu_proveedor.mostrarMensaje(sistema.eliminarUsuario(dni)))
					op_elegida = 5;
			}
			break;
		}
		case 3: {
			menu_consultar_servicios(sistema, dni);
			break;
		}
		case 4: {
			menu_admin_servicios(sistema, dni);
			break;
		}
		};
	}
}

void Menues::menu_usuario(Sistema& sistema, int dni) {
	Menu menu_usuario("Modificar datos personales,Darse de baja,Consultar servicios,Registrarse como proveedor,Desloguearse");
	menu_usuario.setTitulo("Menu de Usuarios");
	menu_usuario.setMensajeDeExito(2,"Se ha dado de baja en el sistema");
	menu_usuario.setMensajeDeFracaso(2,"Error del sistema: no se pudo dar de baja");
	menu_usuario.setMensajeDeExito(4,"Se ha registrado como proveedor exitosamente");
	menu_usuario.setMensajeDeFracaso(4,"Error del sistema: no se pudo registrar como proveedor");

	int op_elegida = 0;
	while(op_elegida != 5) {
		op_elegida = menu_usuario.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			menu_modif_usuarios(sistema, dni);
			break;
		}
		case 2: {
			string msj = "Esta seguro que desea darse de baja en el sistema?";
			if(Menu::pedirConfirmacion(msj)) {
				if(menu_usuario.mostrarMensaje(sistema.eliminarUsuario(dni)))
					op_elegida = 5;
			}
			break;
		}
		case 3: {
			menu_consultar_servicios(sistema, dni);
			break;
		}
		case 4: {
			string msj = "Se registrará como proveedor, desea continuar?";
			if(Menu::pedirConfirmacion(msj)) {
				if(menu_usuario.mostrarMensaje(sistema.registrarProveedor(dni)))
					op_elegida = 5;
			}
			break;
		}
		};
	}
}

void Menues::menu_inicio(Sistema& sistema) {
	Menu menu_inicio("Loguearse,Registrarse,Salir");
	menu_inicio.setTitulo("Menu de Inicio");
	menu_inicio.setMensajeDeExito(1, "Se ha logueado correctamente");
	menu_inicio.setMensajeDeExito(2, "Se ha registrado el usuario correctamente");
	menu_inicio.setMensajeDeFracaso(1, "DNI o Password erroneo. No se pudo loguear");
	menu_inicio.setMensajeDeFracaso(2, "Error del sistema: no se pudo registrar el usuario");

	Formulario logueo("DNI,Password");
	logueo.setAtributos(0,7,8,true);
	logueo.setAtributos(1,4,9);

	Formulario registro("DNI,Nombre,Apellido,Email1,Email2,Email3,Password,Provincia");
	int minSize[8] = {7, 2, 2, 3, 3, 3, 9, 2};
	int maxSize[8] = {8, 100, 100, 100, 100, 100, 9, 100};
	registro.setValorNumerico(0, true);
	registro.setLongitudesMimimas(minSize);
	registro.setLongitudesMaximas(maxSize);
	registro.setConsultarIngreso(4, true);
	registro.setConsultarIngreso(5, true);
	registro.setDependenciaDeIngreso(5, 4);

	int op_elegida = 0;
	while(op_elegida != 3) {
		op_elegida = menu_inicio.mostrarOpciones();

		switch(op_elegida) {
		case 1: {
			logueo.pedirDatos();

			int dni = logueo.getDatoAsInt(0);
			string pass = logueo.getDatoAsStr(1);

			char tipo_usuario = sistema.loguearUsuario(dni, pass);
			menu_inicio.mostrarMensaje(tipo_usuario);

			switch(tipo_usuario) {
			case 'U': {
				menu_usuario(sistema, dni);
				break;
			}
			case 'P': {
				menu_proveedor(sistema, dni);
				break;
			}
			case 'A': {
				menu_administrador(sistema);
				break;
			}
			};
			break;
		}
		case 2: {
			registro.pedirDatos();
			while(!sistema.passwordValida(registro.getDatoAsStr(6))) {
				cout << "La contraseña tiene caracteres inválidos, intente nuevamente" << endl;
				registro.pedirDatos(6);
			}

			Usuario nuevo(registro.getDatoAsInt(0));
			nuevo.setNombre(registro.getDatoAsStr(1));
			nuevo.setApellido(registro.getDatoAsStr(2));
			nuevo.addEmail(registro.getDatoAsStr(3));
			if(registro.seIngresoElCampo(4))
				nuevo.addEmail(registro.getDatoAsStr(4));
			if(registro.seIngresoElCampo(5))
				nuevo.addEmail(registro.getDatoAsStr(5));
			nuevo.setPassword(registro.getDatoAsStr(6));
			nuevo.setProvincia(registro.getDatoAsStr(7));
			nuevo.setTipo('U');

			menu_inicio.mostrarMensaje(sistema.registrarUsuario(nuevo));
			break;
		}
		};
	}
}
